#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "tolua++.h"

/* Exported function */
TOLUA_API int  tolua_luaQString_open (lua_State* tolua_S);

#include "./../luaQt.h"
#include "./../luaQString.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_QStringList (lua_State* tolua_S)
{
 QStringList* self = (QStringList*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_uint (lua_State* tolua_S)
{
 uint* self = (uint*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_qulonglong (lua_State* tolua_S)
{
 qulonglong* self = (qulonglong*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QCharRef (lua_State* tolua_S)
{
 QCharRef* self = (QCharRef*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QChar (lua_State* tolua_S)
{
 QChar* self = (QChar*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_qlonglong (lua_State* tolua_S)
{
 qlonglong* self = (qlonglong*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QLatin1Char (lua_State* tolua_S)
{
 QLatin1Char* self = (QLatin1Char*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_ulong (lua_State* tolua_S)
{
 ulong* self = (ulong*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__wstring (lua_State* tolua_S)
{
 std::wstring* self = (std::wstring*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QVector_QStringRef_ (lua_State* tolua_S)
{
 QVector<QStringRef>* self = (QVector<QStringRef>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QStringRef (lua_State* tolua_S)
{
 QStringRef* self = (QStringRef*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QString (lua_State* tolua_S)
{
 QString* self = (QString*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QByteArray (lua_State* tolua_S)
{
 QByteArray* self = (QByteArray*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QVector_uint_ (lua_State* tolua_S)
{
 QVector<uint>* self = (QVector<uint>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_ushort (lua_State* tolua_S)
{
 ushort* self = (ushort*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QLatin1String (lua_State* tolua_S)
{
 QLatin1String* self = (QLatin1String*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"uint");
 tolua_usertype(tolua_S,"QChar");
 tolua_usertype(tolua_S,"qlonglong");
 tolua_usertype(tolua_S,"QLatin1Char");
 tolua_usertype(tolua_S,"QVector<uint>");
 tolua_usertype(tolua_S,"ushort");
 tolua_usertype(tolua_S,"QRegExp");
 tolua_usertype(tolua_S,"wchar_t");
 tolua_usertype(tolua_S,"qulonglong");
 tolua_usertype(tolua_S,"QCharRef");
 tolua_usertype(tolua_S,"QVector<QStringRef>");
 tolua_usertype(tolua_S,"char16_t");
 tolua_usertype(tolua_S,"QRegularExpression");
 tolua_usertype(tolua_S,"ulong");
 tolua_usertype(tolua_S,"std::wstring");
 tolua_usertype(tolua_S,"char32_t");
 tolua_usertype(tolua_S,"QStringList");
 tolua_usertype(tolua_S,"QString");
 tolua_usertype(tolua_S,"QByteArray");
 tolua_usertype(tolua_S,"QRegularExpressionMatch");
 tolua_usertype(tolua_S,"QStringRef");
 tolua_usertype(tolua_S,"QLatin1String");
}

/* method: new of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_new00
static int tolua_luaQString_QLatin1String_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QLatin1String",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QLatin1String* tolua_ret = (QLatin1String*)  Mtolua_new((QLatin1String)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QLatin1String");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_new00_local
static int tolua_luaQString_QLatin1String_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QLatin1String",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QLatin1String* tolua_ret = (QLatin1String*)  Mtolua_new((QLatin1String)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_new01
static int tolua_luaQString_QLatin1String_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QLatin1String",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const char* s = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   QLatin1String* tolua_ret = (QLatin1String*)  Mtolua_new((QLatin1String)(s));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QLatin1String");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QLatin1String_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_new01_local
static int tolua_luaQString_QLatin1String_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QLatin1String",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const char* s = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   QLatin1String* tolua_ret = (QLatin1String*)  Mtolua_new((QLatin1String)(s));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QLatin1String_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_new02
static int tolua_luaQString_QLatin1String_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QLatin1String",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const char* s = ((const char*)  tolua_tostring(tolua_S,2,0));
  int sz = ((int)  tolua_tonumber(tolua_S,3,0));
  {
   QLatin1String* tolua_ret = (QLatin1String*)  Mtolua_new((QLatin1String)(s,sz));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QLatin1String");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QLatin1String_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_new02_local
static int tolua_luaQString_QLatin1String_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QLatin1String",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const char* s = ((const char*)  tolua_tostring(tolua_S,2,0));
  int sz = ((int)  tolua_tonumber(tolua_S,3,0));
  {
   QLatin1String* tolua_ret = (QLatin1String*)  Mtolua_new((QLatin1String)(s,sz));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QLatin1String_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_new03
static int tolua_luaQString_QLatin1String_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QLatin1String",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QByteArray* s = ((const QByteArray*)  tolua_tousertype(tolua_S,2,0));
  {
   QLatin1String* tolua_ret = (QLatin1String*)  Mtolua_new((QLatin1String)(*s));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QLatin1String");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QLatin1String_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_new03_local
static int tolua_luaQString_QLatin1String_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QLatin1String",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QByteArray* s = ((const QByteArray*)  tolua_tousertype(tolua_S,2,0));
  {
   QLatin1String* tolua_ret = (QLatin1String*)  Mtolua_new((QLatin1String)(*s));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QLatin1String_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: latin1 of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_latin100
static int tolua_luaQString_QLatin1String_latin100(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QLatin1String",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QLatin1String* self = (const QLatin1String*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'latin1'", NULL);
#endif
  {
   const char* tolua_ret = (const char*)  self->latin1();
   tolua_pushstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'latin1'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_size00
static int tolua_luaQString_QLatin1String_size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QLatin1String",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QLatin1String* self = (const QLatin1String*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: data of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_data00
static int tolua_luaQString_QLatin1String_data00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QLatin1String",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QLatin1String* self = (const QLatin1String*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'data'", NULL);
#endif
  {
   const char* tolua_ret = (const char*)  self->data();
   tolua_pushstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'data'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: at of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_at00
static int tolua_luaQString_QLatin1String_at00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QLatin1String",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QLatin1String* self = (const QLatin1String*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'at'", NULL);
#endif
  {
   QLatin1Char tolua_ret = (QLatin1Char)  self->at(i);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QLatin1Char)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1Char");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QLatin1Char));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1Char");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'at'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String__geti00
static int tolua_luaQString_QLatin1String__geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QLatin1String",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QLatin1String* self = (const QLatin1String*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   QLatin1Char tolua_ret = (QLatin1Char)  self->operator[](i);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QLatin1Char)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1Char");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QLatin1Char));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1Char");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: mid of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_mid00
static int tolua_luaQString_QLatin1String_mid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QLatin1String",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QLatin1String* self = (const QLatin1String*)  tolua_tousertype(tolua_S,1,0);
  int pos = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mid'", NULL);
#endif
  {
   QLatin1String tolua_ret = (QLatin1String)  self->mid(pos);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QLatin1String)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QLatin1String));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'mid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: mid of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_mid01
static int tolua_luaQString_QLatin1String_mid01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QLatin1String",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QLatin1String* self = (const QLatin1String*)  tolua_tousertype(tolua_S,1,0);
  int pos = ((int)  tolua_tonumber(tolua_S,2,0));
  int n = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mid'", NULL);
#endif
  {
   QLatin1String tolua_ret = (QLatin1String)  self->mid(pos,n);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QLatin1String)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QLatin1String));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QLatin1String_mid00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: left of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_left00
static int tolua_luaQString_QLatin1String_left00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QLatin1String",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QLatin1String* self = (const QLatin1String*)  tolua_tousertype(tolua_S,1,0);
  int n = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'left'", NULL);
#endif
  {
   QLatin1String tolua_ret = (QLatin1String)  self->left(n);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QLatin1String)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QLatin1String));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'left'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: right of class  QLatin1String */
#ifndef TOLUA_DISABLE_tolua_luaQString_QLatin1String_right00
static int tolua_luaQString_QLatin1String_right00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QLatin1String",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QLatin1String* self = (const QLatin1String*)  tolua_tousertype(tolua_S,1,0);
  int n = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'right'", NULL);
#endif
  {
   QLatin1String tolua_ret = (QLatin1String)  self->right(n);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QLatin1String)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QLatin1String));
     tolua_pushusertype(tolua_S,tolua_obj,"QLatin1String");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'right'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new00
static int tolua_luaQString_QString_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new00_local
static int tolua_luaQString_QString_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new01
static int tolua_luaQString_QString_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QChar* unicode = ((const QChar*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)(unicode,size));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new01_local
static int tolua_luaQString_QString_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QChar* unicode = ((const QChar*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)(unicode,size));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new02
static int tolua_luaQString_QString_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)(c));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new02_local
static int tolua_luaQString_QString_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)(c));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new03
static int tolua_luaQString_QString_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int size = ((int)  tolua_tonumber(tolua_S,2,0));
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,3,0));
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)(size,c));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new03_local
static int tolua_luaQString_QString_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int size = ((int)  tolua_tonumber(tolua_S,2,0));
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,3,0));
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)(size,c));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new04
static int tolua_luaQString_QString_new04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QLatin1String latin1 = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)(latin1));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_new03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new04_local
static int tolua_luaQString_QString_new04_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QLatin1String latin1 = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)(latin1));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_new03_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new05
static int tolua_luaQString_QString_new05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* tolua_var_1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)(*tolua_var_1));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_new04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_new05_local
static int tolua_luaQString_QString_new05_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* tolua_var_1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  {
   QString* tolua_ret = (QString*)  Mtolua_new((QString)(*tolua_var_1));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_new04_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_delete00
static int tolua_luaQString_QString_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_size00
static int tolua_luaQString_QString_size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: count of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_count00
static int tolua_luaQString_QString_count00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'count'", NULL);
#endif
  {
   int tolua_ret = (int)  self->count();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'count'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: length of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_length00
static int tolua_luaQString_QString_length00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length'", NULL);
#endif
  {
   int tolua_ret = (int)  self->length();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isEmpty of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_isEmpty00
static int tolua_luaQString_QString_isEmpty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isEmpty'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isEmpty();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isEmpty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resize of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_resize00
static int tolua_luaQString_QString_resize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int size = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resize'", NULL);
#endif
  {
   self->resize(size);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resize of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_resize01
static int tolua_luaQString_QString_resize01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int size = ((int)  tolua_tonumber(tolua_S,2,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resize'", NULL);
#endif
  {
   self->resize(size,fillChar);
  }
 }
 return 0;
tolua_lerror:
 return tolua_luaQString_QString_resize00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fill of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fill00
static int tolua_luaQString_QString_fill00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'fill'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->fill(c,size);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fill'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: truncate of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_truncate00
static int tolua_luaQString_QString_truncate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int pos = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'truncate'", NULL);
#endif
  {
   self->truncate(pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'truncate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: chop of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_chop00
static int tolua_luaQString_QString_chop00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int n = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'chop'", NULL);
#endif
  {
   self->chop(n);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'chop'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: capacity of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_capacity00
static int tolua_luaQString_QString_capacity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'capacity'", NULL);
#endif
  {
   int tolua_ret = (int)  self->capacity();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'capacity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reserve of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_reserve00
static int tolua_luaQString_QString_reserve00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int size = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reserve'", NULL);
#endif
  {
   self->reserve(size);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reserve'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: squeeze of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_squeeze00
static int tolua_luaQString_QString_squeeze00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'squeeze'", NULL);
#endif
  {
   self->squeeze();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'squeeze'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: unicode of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_unicode00
static int tolua_luaQString_QString_unicode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unicode'", NULL);
#endif
  {
   const QChar* tolua_ret = (const QChar*)  self->unicode();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const QChar");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'unicode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: data of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_data00
static int tolua_luaQString_QString_data00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'data'", NULL);
#endif
  {
   QChar* tolua_ret = (QChar*)  self->data();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QChar");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'data'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: data of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_data01
static int tolua_luaQString_QString_data01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'data'", NULL);
#endif
  {
   const QChar* tolua_ret = (const QChar*)  self->data();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const QChar");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_data00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: constData of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_constData00
static int tolua_luaQString_QString_constData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'constData'", NULL);
#endif
  {
   const QChar* tolua_ret = (const QChar*)  self->constData();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const QChar");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'constData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: detach of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_detach00
static int tolua_luaQString_QString_detach00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'detach'", NULL);
#endif
  {
   self->detach();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'detach'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isDetached of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_isDetached00
static int tolua_luaQString_QString_isDetached00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isDetached'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isDetached();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isDetached'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isSharedWith of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_isSharedWith00
static int tolua_luaQString_QString_isSharedWith00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* other = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isSharedWith'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isSharedWith(*other);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isSharedWith'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_clear00
static int tolua_luaQString_QString_clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: at of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_at00
static int tolua_luaQString_QString_at00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'at'", NULL);
#endif
  {
   const QChar tolua_ret = (const QChar)  self->at(i);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QChar)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"const QChar");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const QChar));
     tolua_pushusertype(tolua_S,tolua_obj,"const QChar");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'at'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__geti00
static int tolua_luaQString_QString__geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   const QChar tolua_ret = (const QChar)  self->operator[](i);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QChar)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"const QChar");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const QChar));
     tolua_pushusertype(tolua_S,tolua_obj,"const QChar");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__geti01
static int tolua_luaQString_QString__geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   QCharRef tolua_ret = (QCharRef)  self->operator[](i);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QCharRef)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QCharRef");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QCharRef));
     tolua_pushusertype(tolua_S,tolua_obj,"QCharRef");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString__geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg00
static int tolua_luaQString_QString_arg00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"qlonglong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  qlonglong a = *((qlonglong*)  tolua_tousertype(tolua_S,2,0));
  int fieldwidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldwidth,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'arg'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg01
static int tolua_luaQString_QString_arg01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"qlonglong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  qlonglong a = *((qlonglong*)  tolua_tousertype(tolua_S,2,0));
  int fieldwidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldwidth,base,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg02
static int tolua_luaQString_QString_arg02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"qulonglong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  qulonglong a = *((qulonglong*)  tolua_tousertype(tolua_S,2,0));
  int fieldwidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldwidth,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg03
static int tolua_luaQString_QString_arg03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"qulonglong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  qulonglong a = *((qulonglong*)  tolua_tousertype(tolua_S,2,0));
  int fieldwidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldwidth,base,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg04
static int tolua_luaQString_QString_arg04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  long a = ((long)  tolua_tonumber(tolua_S,2,0));
  int fieldwidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldwidth,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg05
static int tolua_luaQString_QString_arg05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  long a = ((long)  tolua_tonumber(tolua_S,2,0));
  int fieldwidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldwidth,base,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg06
static int tolua_luaQString_QString_arg06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"ulong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  ulong a = *((ulong*)  tolua_tousertype(tolua_S,2,0));
  int fieldwidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldwidth,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg07
static int tolua_luaQString_QString_arg07(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"ulong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  ulong a = *((ulong*)  tolua_tousertype(tolua_S,2,0));
  int fieldwidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldwidth,base,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg06(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg08
static int tolua_luaQString_QString_arg08(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int a = ((int)  tolua_tonumber(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg07(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg09
static int tolua_luaQString_QString_arg09(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int a = ((int)  tolua_tonumber(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,base,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg08(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg10
static int tolua_luaQString_QString_arg10(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"uint",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  uint a = *((uint*)  tolua_tousertype(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg09(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg11
static int tolua_luaQString_QString_arg11(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"uint",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  uint a = *((uint*)  tolua_tousertype(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,base,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg10(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg12
static int tolua_luaQString_QString_arg12(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  short a = ((short)  tolua_tonumber(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg11(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg13
static int tolua_luaQString_QString_arg13(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  short a = ((short)  tolua_tonumber(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,base,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg12(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg14
static int tolua_luaQString_QString_arg14(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"ushort",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  ushort a = *((ushort*)  tolua_tousertype(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg13(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg15
static int tolua_luaQString_QString_arg15(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"ushort",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  ushort a = *((ushort*)  tolua_tousertype(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  int base = ((int)  tolua_tonumber(tolua_S,4,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,base,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg14(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg16
static int tolua_luaQString_QString_arg16(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  double a = ((double)  tolua_tonumber(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  char fmt = ((char)  tolua_tonumber(tolua_S,4,'g'));
  int prec = ((int)  tolua_tonumber(tolua_S,5,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,fmt,prec);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg15(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg17
static int tolua_luaQString_QString_arg17(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  double a = ((double)  tolua_tonumber(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  char fmt = ((char)  tolua_tonumber(tolua_S,4,0));
  int prec = ((int)  tolua_tonumber(tolua_S,5,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,fmt,prec,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg16(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg18
static int tolua_luaQString_QString_arg18(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  char a = ((char)  tolua_tonumber(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg17(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg19
static int tolua_luaQString_QString_arg19(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  char a = ((char)  tolua_tonumber(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg18(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg20
static int tolua_luaQString_QString_arg20(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar a = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg19(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg21
static int tolua_luaQString_QString_arg21(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar a = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(a,fieldWidth,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg20(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg22
static int tolua_luaQString_QString_arg22(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* a = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(*a,fieldWidth);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg21(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg23
static int tolua_luaQString_QString_arg23(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* a = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  int fieldWidth = ((int)  tolua_tonumber(tolua_S,3,0));
  QChar fillChar = *((QChar*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(*a,fieldWidth,fillChar);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg22(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg24
static int tolua_luaQString_QString_arg24(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* a1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* a2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(*a1,*a2);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg23(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg25
static int tolua_luaQString_QString_arg25(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* a1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* a2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  const QString* a3 = ((const QString*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(*a1,*a2,*a3);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg24(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg26
static int tolua_luaQString_QString_arg26(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* a1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* a2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  const QString* a3 = ((const QString*)  tolua_tousertype(tolua_S,4,0));
  const QString* a4 = ((const QString*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(*a1,*a2,*a3,*a4);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg25(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg27
static int tolua_luaQString_QString_arg27(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* a1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* a2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  const QString* a3 = ((const QString*)  tolua_tousertype(tolua_S,4,0));
  const QString* a4 = ((const QString*)  tolua_tousertype(tolua_S,5,0));
  const QString* a5 = ((const QString*)  tolua_tousertype(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(*a1,*a2,*a3,*a4,*a5);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg26(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg28
static int tolua_luaQString_QString_arg28(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* a1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* a2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  const QString* a3 = ((const QString*)  tolua_tousertype(tolua_S,4,0));
  const QString* a4 = ((const QString*)  tolua_tousertype(tolua_S,5,0));
  const QString* a5 = ((const QString*)  tolua_tousertype(tolua_S,6,0));
  const QString* a6 = ((const QString*)  tolua_tousertype(tolua_S,7,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(*a1,*a2,*a3,*a4,*a5,*a6);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg27(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg29
static int tolua_luaQString_QString_arg29(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,8,&tolua_err) || !tolua_isusertype(tolua_S,8,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,9,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* a1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* a2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  const QString* a3 = ((const QString*)  tolua_tousertype(tolua_S,4,0));
  const QString* a4 = ((const QString*)  tolua_tousertype(tolua_S,5,0));
  const QString* a5 = ((const QString*)  tolua_tousertype(tolua_S,6,0));
  const QString* a6 = ((const QString*)  tolua_tousertype(tolua_S,7,0));
  const QString* a7 = ((const QString*)  tolua_tousertype(tolua_S,8,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(*a1,*a2,*a3,*a4,*a5,*a6,*a7);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg28(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg30
static int tolua_luaQString_QString_arg30(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,8,&tolua_err) || !tolua_isusertype(tolua_S,8,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,9,&tolua_err) || !tolua_isusertype(tolua_S,9,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,10,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* a1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* a2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  const QString* a3 = ((const QString*)  tolua_tousertype(tolua_S,4,0));
  const QString* a4 = ((const QString*)  tolua_tousertype(tolua_S,5,0));
  const QString* a5 = ((const QString*)  tolua_tousertype(tolua_S,6,0));
  const QString* a6 = ((const QString*)  tolua_tousertype(tolua_S,7,0));
  const QString* a7 = ((const QString*)  tolua_tousertype(tolua_S,8,0));
  const QString* a8 = ((const QString*)  tolua_tousertype(tolua_S,9,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(*a1,*a2,*a3,*a4,*a5,*a6,*a7,*a8);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg29(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: arg of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_arg31
static int tolua_luaQString_QString_arg31(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,8,&tolua_err) || !tolua_isusertype(tolua_S,8,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,9,&tolua_err) || !tolua_isusertype(tolua_S,9,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,10,&tolua_err) || !tolua_isusertype(tolua_S,10,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,11,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* a1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* a2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  const QString* a3 = ((const QString*)  tolua_tousertype(tolua_S,4,0));
  const QString* a4 = ((const QString*)  tolua_tousertype(tolua_S,5,0));
  const QString* a5 = ((const QString*)  tolua_tousertype(tolua_S,6,0));
  const QString* a6 = ((const QString*)  tolua_tousertype(tolua_S,7,0));
  const QString* a7 = ((const QString*)  tolua_tousertype(tolua_S,8,0));
  const QString* a8 = ((const QString*)  tolua_tousertype(tolua_S,9,0));
  const QString* a9 = ((const QString*)  tolua_tousertype(tolua_S,10,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'arg'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->arg(*a1,*a2,*a3,*a4,*a5,*a6,*a7,*a8,*a9);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_arg30(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: indexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_indexOf00
static int tolua_luaQString_QString_indexOf00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'indexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->indexOf(c,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'indexOf'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: indexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_indexOf01
static int tolua_luaQString_QString_indexOf01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'indexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->indexOf(*s,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_indexOf00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: indexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_indexOf02
static int tolua_luaQString_QString_indexOf02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'indexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->indexOf(s,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_indexOf01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: indexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_indexOf03
static int tolua_luaQString_QString_indexOf03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'indexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->indexOf(*s,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_indexOf02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: lastIndexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_lastIndexOf00
static int tolua_luaQString_QString_lastIndexOf00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lastIndexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->lastIndexOf(c,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'lastIndexOf'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: lastIndexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_lastIndexOf01
static int tolua_luaQString_QString_lastIndexOf01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lastIndexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->lastIndexOf(*s,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_lastIndexOf00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: lastIndexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_lastIndexOf02
static int tolua_luaQString_QString_lastIndexOf02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lastIndexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->lastIndexOf(s,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_lastIndexOf01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: lastIndexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_lastIndexOf03
static int tolua_luaQString_QString_lastIndexOf03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lastIndexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->lastIndexOf(*s,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_lastIndexOf02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: contains of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_contains00
static int tolua_luaQString_QString_contains00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'contains'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->contains(c);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'contains'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: contains of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_contains01
static int tolua_luaQString_QString_contains01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'contains'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->contains(*s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_contains00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: contains of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_contains02
static int tolua_luaQString_QString_contains02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'contains'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->contains(s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_contains01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: contains of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_contains03
static int tolua_luaQString_QString_contains03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'contains'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->contains(*s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_contains02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: count of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_count01
static int tolua_luaQString_QString_count01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'count'", NULL);
#endif
  {
   int tolua_ret = (int)  self->count(c);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_count00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: count of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_count02
static int tolua_luaQString_QString_count02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'count'", NULL);
#endif
  {
   int tolua_ret = (int)  self->count(*s);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_count01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: count of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_count03
static int tolua_luaQString_QString_count03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'count'", NULL);
#endif
  {
   int tolua_ret = (int)  self->count(*s);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_count02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: indexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_indexOf04
static int tolua_luaQString_QString_indexOf04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegExp",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegExp* tolua_var_2 = ((const QRegExp*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'indexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->indexOf(*tolua_var_2,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_indexOf03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: lastIndexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_lastIndexOf04
static int tolua_luaQString_QString_lastIndexOf04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegExp",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegExp* tolua_var_3 = ((const QRegExp*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lastIndexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->lastIndexOf(*tolua_var_3,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_lastIndexOf03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: contains of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_contains04
static int tolua_luaQString_QString_contains04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegExp",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegExp* rx = ((const QRegExp*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'contains'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->contains(*rx);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_contains03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: count of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_count04
static int tolua_luaQString_QString_count04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegExp",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegExp* tolua_var_4 = ((const QRegExp*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'count'", NULL);
#endif
  {
   int tolua_ret = (int)  self->count(*tolua_var_4);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_count03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: indexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_indexOf05
static int tolua_luaQString_QString_indexOf05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRegExp",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QRegExp* tolua_var_5 = ((QRegExp*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'indexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->indexOf(*tolua_var_5,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_indexOf04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: lastIndexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_lastIndexOf05
static int tolua_luaQString_QString_lastIndexOf05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRegExp",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QRegExp* tolua_var_6 = ((QRegExp*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lastIndexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->lastIndexOf(*tolua_var_6,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_lastIndexOf04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: contains of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_contains05
static int tolua_luaQString_QString_contains05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QRegExp",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QRegExp* rx = ((QRegExp*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'contains'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->contains(*rx);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_contains04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: indexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_indexOf06
static int tolua_luaQString_QString_indexOf06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* re = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'indexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->indexOf(*re,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_indexOf05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: indexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_indexOf07
static int tolua_luaQString_QString_indexOf07(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"QRegularExpressionMatch",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* re = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,0));
  QRegularExpressionMatch* rmatch = ((QRegularExpressionMatch*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'indexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->indexOf(*re,from,rmatch);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_indexOf06(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: lastIndexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_lastIndexOf06
static int tolua_luaQString_QString_lastIndexOf06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* re = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lastIndexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->lastIndexOf(*re,from);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_lastIndexOf05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: lastIndexOf of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_lastIndexOf07
static int tolua_luaQString_QString_lastIndexOf07(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"QRegularExpressionMatch",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* re = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
  int from = ((int)  tolua_tonumber(tolua_S,3,0));
  QRegularExpressionMatch* rmatch = ((QRegularExpressionMatch*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lastIndexOf'", NULL);
#endif
  {
   int tolua_ret = (int)  self->lastIndexOf(*re,from,rmatch);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_lastIndexOf06(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: contains of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_contains06
static int tolua_luaQString_QString_contains06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* re = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'contains'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->contains(*re);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_contains05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: contains of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_contains07
static int tolua_luaQString_QString_contains07(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"QRegularExpressionMatch",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* re = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
  QRegularExpressionMatch* match = ((QRegularExpressionMatch*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'contains'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->contains(*re,match);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_contains06(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: count of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_count05
static int tolua_luaQString_QString_count05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* re = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'count'", NULL);
#endif
  {
   int tolua_ret = (int)  self->count(*re);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_count04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: section of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_section00
static int tolua_luaQString_QString_section00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar sep = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  int start = ((int)  tolua_tonumber(tolua_S,3,0));
  int end = ((int)  tolua_tonumber(tolua_S,4,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'section'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->section(sep,start,end);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'section'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: section of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_section01
static int tolua_luaQString_QString_section01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* in_sep = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  int start = ((int)  tolua_tonumber(tolua_S,3,0));
  int end = ((int)  tolua_tonumber(tolua_S,4,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'section'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->section(*in_sep,start,end);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_section00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: section of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_section02
static int tolua_luaQString_QString_section02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegExp",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegExp* reg = ((const QRegExp*)  tolua_tousertype(tolua_S,2,0));
  int start = ((int)  tolua_tonumber(tolua_S,3,0));
  int end = ((int)  tolua_tonumber(tolua_S,4,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'section'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->section(*reg,start,end);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_section01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: section of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_section03
static int tolua_luaQString_QString_section03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* re = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
  int start = ((int)  tolua_tonumber(tolua_S,3,0));
  int end = ((int)  tolua_tonumber(tolua_S,4,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'section'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->section(*re,start,end);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_section02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: left of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_left00
static int tolua_luaQString_QString_left00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int n = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'left'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->left(n);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'left'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: right of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_right00
static int tolua_luaQString_QString_right00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int n = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'right'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->right(n);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'right'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: mid of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_mid00
static int tolua_luaQString_QString_mid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int position = ((int)  tolua_tonumber(tolua_S,2,0));
  int n = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mid'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->mid(position,n);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'mid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: leftRef of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_leftRef00
static int tolua_luaQString_QString_leftRef00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int n = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'leftRef'", NULL);
#endif
  {
   QStringRef tolua_ret = (QStringRef)  self->leftRef(n);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QStringRef)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringRef");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QStringRef));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringRef");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'leftRef'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rightRef of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_rightRef00
static int tolua_luaQString_QString_rightRef00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int n = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rightRef'", NULL);
#endif
  {
   QStringRef tolua_ret = (QStringRef)  self->rightRef(n);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QStringRef)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringRef");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QStringRef));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringRef");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'rightRef'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: midRef of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_midRef00
static int tolua_luaQString_QString_midRef00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int position = ((int)  tolua_tonumber(tolua_S,2,0));
  int n = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'midRef'", NULL);
#endif
  {
   QStringRef tolua_ret = (QStringRef)  self->midRef(position,n);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QStringRef)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringRef");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QStringRef));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringRef");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'midRef'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startsWith of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_startsWith00
static int tolua_luaQString_QString_startsWith00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startsWith'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->startsWith(*s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startsWith'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startsWith of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_startsWith01
static int tolua_luaQString_QString_startsWith01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startsWith'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->startsWith(*s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_startsWith00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: startsWith of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_startsWith02
static int tolua_luaQString_QString_startsWith02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startsWith'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->startsWith(s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_startsWith01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: startsWith of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_startsWith03
static int tolua_luaQString_QString_startsWith03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startsWith'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->startsWith(c);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_startsWith02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: endsWith of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_endsWith00
static int tolua_luaQString_QString_endsWith00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'endsWith'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->endsWith(*s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'endsWith'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: endsWith of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_endsWith01
static int tolua_luaQString_QString_endsWith01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'endsWith'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->endsWith(*s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_endsWith00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: endsWith of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_endsWith02
static int tolua_luaQString_QString_endsWith02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'endsWith'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->endsWith(s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_endsWith01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: endsWith of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_endsWith03
static int tolua_luaQString_QString_endsWith03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'endsWith'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->endsWith(c);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_endsWith02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: leftJustified of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_leftJustified00
static int tolua_luaQString_QString_leftJustified00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int width = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'leftJustified'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->leftJustified(width);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'leftJustified'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: leftJustified of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_leftJustified01
static int tolua_luaQString_QString_leftJustified01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QChar",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int width = ((int)  tolua_tonumber(tolua_S,2,0));
  QChar fill = *((QChar*)  tolua_tousertype(tolua_S,3,0));
  bool trunc = ((bool)  tolua_toboolean(tolua_S,4,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'leftJustified'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->leftJustified(width,fill,trunc);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_leftJustified00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: rightJustified of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_rightJustified00
static int tolua_luaQString_QString_rightJustified00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int width = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rightJustified'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->rightJustified(width);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'rightJustified'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rightJustified of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_rightJustified01
static int tolua_luaQString_QString_rightJustified01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QChar",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int width = ((int)  tolua_tonumber(tolua_S,2,0));
  QChar fill = *((QChar*)  tolua_tousertype(tolua_S,3,0));
  bool trunc = ((bool)  tolua_toboolean(tolua_S,4,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rightJustified'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->rightJustified(width,fill,trunc);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_rightJustified00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: toLower of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toLower00
static int tolua_luaQString_QString_toLower00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toLower'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->toLower();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toLower'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toUpper of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toUpper00
static int tolua_luaQString_QString_toUpper00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toUpper'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->toUpper();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toUpper'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toCaseFolded of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toCaseFolded00
static int tolua_luaQString_QString_toCaseFolded00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toCaseFolded'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->toCaseFolded();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toCaseFolded'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: trimmed of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_trimmed00
static int tolua_luaQString_QString_trimmed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'trimmed'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->trimmed();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'trimmed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: simplified of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_simplified00
static int tolua_luaQString_QString_simplified00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'simplified'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->simplified();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'simplified'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toHtmlEscaped of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toHtmlEscaped00
static int tolua_luaQString_QString_toHtmlEscaped00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toHtmlEscaped'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->toHtmlEscaped();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toHtmlEscaped'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insert of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_insert00
static int tolua_luaQString_QString_insert00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->insert(i,c);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insert'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insert of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_insert01
static int tolua_luaQString_QString_insert01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  const QChar* uc = ((const QChar*)  tolua_tousertype(tolua_S,3,0));
  int len = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->insert(i,uc,len);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_insert00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: insert of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_insert02
static int tolua_luaQString_QString_insert02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->insert(i,*s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_insert01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: insert of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_insert03
static int tolua_luaQString_QString_insert03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->insert(i,*s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_insert02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: insert of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_insert04
static int tolua_luaQString_QString_insert04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->insert(i,s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_insert03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: append of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_append00
static int tolua_luaQString_QString_append00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'append'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->append(c);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'append'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: append of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_append01
static int tolua_luaQString_QString_append01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QChar* uc = ((const QChar*)  tolua_tousertype(tolua_S,2,0));
  int len = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'append'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->append(uc,len);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_append00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: append of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_append02
static int tolua_luaQString_QString_append02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'append'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->append(*s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_append01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: append of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_append03
static int tolua_luaQString_QString_append03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'append'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->append(*s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_append02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: append of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_append04
static int tolua_luaQString_QString_append04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'append'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->append(s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_append03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: prepend of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_prepend00
static int tolua_luaQString_QString_prepend00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'prepend'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->prepend(c);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'prepend'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: prepend of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_prepend01
static int tolua_luaQString_QString_prepend01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QChar* uc = ((const QChar*)  tolua_tousertype(tolua_S,2,0));
  int len = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'prepend'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->prepend(uc,len);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_prepend00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: prepend of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_prepend02
static int tolua_luaQString_QString_prepend02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'prepend'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->prepend(*s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_prepend01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: prepend of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_prepend03
static int tolua_luaQString_QString_prepend03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'prepend'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->prepend(*s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_prepend02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: prepend of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_prepend04
static int tolua_luaQString_QString_prepend04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'prepend'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->prepend(s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_prepend03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: remove of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_remove00
static int tolua_luaQString_QString_remove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  int len = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->remove(i,len);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'remove'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: remove of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_remove01
static int tolua_luaQString_QString_remove01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->remove(c);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_remove00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: remove of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_remove02
static int tolua_luaQString_QString_remove02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->remove(*s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_remove01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace00
static int tolua_luaQString_QString_replace00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  int len = ((int)  tolua_tonumber(tolua_S,3,0));
  QChar after = *((QChar*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(i,len,after);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'replace'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace01
static int tolua_luaQString_QString_replace01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  int len = ((int)  tolua_tonumber(tolua_S,3,0));
  const QChar* s = ((const QChar*)  tolua_tousertype(tolua_S,4,0));
  int slen = ((int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(i,len,s,slen);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace02
static int tolua_luaQString_QString_replace02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  int len = ((int)  tolua_tonumber(tolua_S,3,0));
  const QString* after = ((const QString*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(i,len,*after);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace03
static int tolua_luaQString_QString_replace03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QChar before = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  QChar after = *((QChar*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(before,after);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace04
static int tolua_luaQString_QString_replace04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QChar* before = ((const QChar*)  tolua_tousertype(tolua_S,2,0));
  int blen = ((int)  tolua_tonumber(tolua_S,3,0));
  const QChar* after = ((const QChar*)  tolua_tousertype(tolua_S,4,0));
  int alen = ((int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(before,blen,after,alen);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace05
static int tolua_luaQString_QString_replace05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String before = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
  QLatin1String after = *((QLatin1String*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(before,after);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace06
static int tolua_luaQString_QString_replace06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String before = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
  const QString* after = ((const QString*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(before,*after);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace07
static int tolua_luaQString_QString_replace07(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* before = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  QLatin1String after = *((QLatin1String*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(*before,after);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace06(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace08
static int tolua_luaQString_QString_replace08(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* before = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* after = ((const QString*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(*before,*after);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace07(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace09
static int tolua_luaQString_QString_replace09(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  const QString* after = ((const QString*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(c,*after);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace08(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace10
static int tolua_luaQString_QString_replace10(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
  QLatin1String after = *((QLatin1String*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(c,after);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace09(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_replace11
static int tolua_luaQString_QString_replace11(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* re = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
  const QString* after = ((const QString*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->replace(*re,*after);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_replace10(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: remove of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_remove03
static int tolua_luaQString_QString_remove03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* re = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->remove(*re);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_remove02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: split of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_split00
static int tolua_luaQString_QString_split00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* sep = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'split'", NULL);
#endif
  {
   QStringList tolua_ret = (QStringList)  self->split(*sep);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QStringList)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QStringList));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'split'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: splitRef of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_splitRef00
static int tolua_luaQString_QString_splitRef00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* sep = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'splitRef'", NULL);
#endif
  {
   QVector<QStringRef> tolua_ret = (QVector<QStringRef>)  self->splitRef(*sep);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QVector<QStringRef>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QVector<QStringRef>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QVector<QStringRef>));
     tolua_pushusertype(tolua_S,tolua_obj,"QVector<QStringRef>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'splitRef'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: split of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_split01
static int tolua_luaQString_QString_split01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar sep = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'split'", NULL);
#endif
  {
   QStringList tolua_ret = (QStringList)  self->split(sep);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QStringList)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QStringList));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_split00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: splitRef of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_splitRef01
static int tolua_luaQString_QString_splitRef01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QChar sep = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'splitRef'", NULL);
#endif
  {
   QVector<QStringRef> tolua_ret = (QVector<QStringRef>)  self->splitRef(sep);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QVector<QStringRef>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QVector<QStringRef>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QVector<QStringRef>));
     tolua_pushusertype(tolua_S,tolua_obj,"QVector<QStringRef>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_splitRef00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: split of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_split02
static int tolua_luaQString_QString_split02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegExp",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegExp* sep = ((const QRegExp*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'split'", NULL);
#endif
  {
   QStringList tolua_ret = (QStringList)  self->split(*sep);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QStringList)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QStringList));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_split01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: splitRef of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_splitRef02
static int tolua_luaQString_QString_splitRef02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegExp",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegExp* sep = ((const QRegExp*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'splitRef'", NULL);
#endif
  {
   QVector<QStringRef> tolua_ret = (QVector<QStringRef>)  self->splitRef(*sep);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QVector<QStringRef>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QVector<QStringRef>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QVector<QStringRef>));
     tolua_pushusertype(tolua_S,tolua_obj,"QVector<QStringRef>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_splitRef01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: split of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_split03
static int tolua_luaQString_QString_split03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* sep = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'split'", NULL);
#endif
  {
   QStringList tolua_ret = (QStringList)  self->split(*sep);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QStringList)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QStringList));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_split02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: splitRef of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_splitRef03
static int tolua_luaQString_QString_splitRef03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QRegularExpression",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QRegularExpression* sep = ((const QRegularExpression*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'splitRef'", NULL);
#endif
  {
   QVector<QStringRef> tolua_ret = (QVector<QStringRef>)  self->splitRef(*sep);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QVector<QStringRef>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QVector<QStringRef>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QVector<QStringRef>));
     tolua_pushusertype(tolua_S,tolua_obj,"QVector<QStringRef>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_splitRef02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: normalized of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_normalized00
static int tolua_luaQString_QString_normalized00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QString::NormalizationForm mode = ((QString::NormalizationForm) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'normalized'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->normalized(mode);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'normalized'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: repeated of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_repeated00
static int tolua_luaQString_QString_repeated00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  int times = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'repeated'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->repeated(times);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'repeated'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: utf16 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_utf1600
static int tolua_luaQString_QString_utf1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'utf16'", NULL);
#endif
  {
   const ushort* tolua_ret = (const ushort*)  self->utf16();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const ushort");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'utf16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toLatin1 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toLatin100
static int tolua_luaQString_QString_toLatin100(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toLatin1'", NULL);
#endif
  {
   QByteArray tolua_ret = (QByteArray)  self->toLatin1();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QByteArray)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QByteArray");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QByteArray));
     tolua_pushusertype(tolua_S,tolua_obj,"QByteArray");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toLatin1'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toUtf8 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toUtf800
static int tolua_luaQString_QString_toUtf800(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toUtf8'", NULL);
#endif
  {
   QByteArray tolua_ret = (QByteArray)  self->toUtf8();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QByteArray)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QByteArray");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QByteArray));
     tolua_pushusertype(tolua_S,tolua_obj,"QByteArray");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toUtf8'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toLocal8Bit of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toLocal8Bit00
static int tolua_luaQString_QString_toLocal8Bit00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toLocal8Bit'", NULL);
#endif
  {
   QByteArray tolua_ret = (QByteArray)  self->toLocal8Bit();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QByteArray)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QByteArray");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QByteArray));
     tolua_pushusertype(tolua_S,tolua_obj,"QByteArray");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toLocal8Bit'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toUcs4 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toUcs400
static int tolua_luaQString_QString_toUcs400(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toUcs4'", NULL);
#endif
  {
   QVector<uint> tolua_ret = (QVector<uint>)  self->toUcs4();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QVector<uint>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QVector<uint>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QVector<uint>));
     tolua_pushusertype(tolua_S,tolua_obj,"QVector<uint>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toUcs4'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromLatin1 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromLatin100
static int tolua_luaQString_QString_fromLatin100(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* str = ((const char*)  tolua_tostring(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
  {
   QString tolua_ret = (QString)  QString::fromLatin1(str,size);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromLatin1'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromUtf8 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromUtf800
static int tolua_luaQString_QString_fromUtf800(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* str = ((const char*)  tolua_tostring(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
  {
   QString tolua_ret = (QString)  QString::fromUtf8(str,size);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromUtf8'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromLocal8Bit of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromLocal8Bit00
static int tolua_luaQString_QString_fromLocal8Bit00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* str = ((const char*)  tolua_tostring(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
  {
   QString tolua_ret = (QString)  QString::fromLocal8Bit(str,size);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromLocal8Bit'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromLatin1 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromLatin101
static int tolua_luaQString_QString_fromLatin101(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QByteArray* str = ((const QByteArray*)  tolua_tousertype(tolua_S,2,0));
  {
   QString tolua_ret = (QString)  QString::fromLatin1(*str);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_fromLatin100(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromUtf8 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromUtf801
static int tolua_luaQString_QString_fromUtf801(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QByteArray* str = ((const QByteArray*)  tolua_tousertype(tolua_S,2,0));
  {
   QString tolua_ret = (QString)  QString::fromUtf8(*str);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_fromUtf800(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromLocal8Bit of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromLocal8Bit01
static int tolua_luaQString_QString_fromLocal8Bit01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QByteArray* str = ((const QByteArray*)  tolua_tousertype(tolua_S,2,0));
  {
   QString tolua_ret = (QString)  QString::fromLocal8Bit(*str);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_fromLocal8Bit00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromUtf16 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromUtf1600
static int tolua_luaQString_QString_fromUtf1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const ushort",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ushort* tolua_var_7 = ((const ushort*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
  {
   QString tolua_ret = (QString)  QString::fromUtf16(tolua_var_7,size);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromUtf16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromUcs4 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromUcs400
static int tolua_luaQString_QString_fromUcs400(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const uint",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const uint* tolua_var_8 = ((const uint*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
  {
   QString tolua_ret = (QString)  QString::fromUcs4(tolua_var_8,size);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromUcs4'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromRawData of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromRawData00
static int tolua_luaQString_QString_fromRawData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QChar* tolua_var_9 = ((const QChar*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,0));
  {
   QString tolua_ret = (QString)  QString::fromRawData(tolua_var_9,size);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromRawData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromUtf16 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromUtf1601
static int tolua_luaQString_QString_fromUtf1601(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const char16_t",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const char16_t* str = ((const char16_t*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
  {
   QString tolua_ret = (QString)  QString::fromUtf16(str,size);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_fromUtf1600(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromUcs4 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromUcs401
static int tolua_luaQString_QString_fromUcs401(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const char32_t",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const char32_t* tolua_var_10 = ((const char32_t*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
  {
   QString tolua_ret = (QString)  QString::fromUcs4(tolua_var_10,size);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_fromUcs400(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: toWCharArray of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toWCharArray00
static int tolua_luaQString_QString_toWCharArray00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"wchar_t",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  wchar_t* array = ((wchar_t*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toWCharArray'", NULL);
#endif
  {
   int tolua_ret = (int)  self->toWCharArray(array);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toWCharArray'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromWCharArray of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromWCharArray00
static int tolua_luaQString_QString_fromWCharArray00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const wchar_t",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const wchar_t* tolua_var_11 = ((const wchar_t*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'fromWCharArray'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->fromWCharArray(tolua_var_11,size);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromWCharArray'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRawData of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setRawData00
static int tolua_luaQString_QString_setRawData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QChar* unicode = ((const QChar*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRawData'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setRawData(unicode,size);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRawData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUnicode of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setUnicode00
static int tolua_luaQString_QString_setUnicode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const QChar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QChar* unicode = ((const QChar*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUnicode'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setUnicode(unicode,size);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUnicode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUtf16 of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setUtf1600
static int tolua_luaQString_QString_setUtf1600(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const ushort",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const ushort* utf16 = ((const ushort*)  tolua_tousertype(tolua_S,2,0));
  int size = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUtf16'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setUtf16(utf16,size);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUtf16'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: compare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_compare00
static int tolua_luaQString_QString_compare00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'compare'", NULL);
#endif
  {
   int tolua_ret = (int)  self->compare(*s);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'compare'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: compare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_compare01
static int tolua_luaQString_QString_compare01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String other = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'compare'", NULL);
#endif
  {
   int tolua_ret = (int)  self->compare(other);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_compare00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: compare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_compare02
static int tolua_luaQString_QString_compare02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* s1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* s2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  {
   int tolua_ret = (int)  QString::compare(*s1,*s2);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_compare01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: compare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_compare03
static int tolua_luaQString_QString_compare03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* s1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  QLatin1String s2 = *((QLatin1String*)  tolua_tousertype(tolua_S,3,0));
  {
   int tolua_ret = (int)  QString::compare(*s1,s2);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_compare02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: compare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_compare04
static int tolua_luaQString_QString_compare04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QLatin1String s1 = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
  const QString* s2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  {
   int tolua_ret = (int)  QString::compare(s1,*s2);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_compare03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: compare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_compare05
static int tolua_luaQString_QString_compare05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'compare'", NULL);
#endif
  {
   int tolua_ret = (int)  self->compare(*s);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_compare04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: compare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_compare06
static int tolua_luaQString_QString_compare06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* s1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QStringRef* s2 = ((const QStringRef*)  tolua_tousertype(tolua_S,3,0));
  {
   int tolua_ret = (int)  QString::compare(*s1,*s2);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_compare05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: localeAwareCompare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_localeAwareCompare00
static int tolua_luaQString_QString_localeAwareCompare00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'localeAwareCompare'", NULL);
#endif
  {
   int tolua_ret = (int)  self->localeAwareCompare(*s);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'localeAwareCompare'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: localeAwareCompare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_localeAwareCompare01
static int tolua_luaQString_QString_localeAwareCompare01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* s1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* s2 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  {
   int tolua_ret = (int)  QString::localeAwareCompare(*s1,*s2);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_localeAwareCompare00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: localeAwareCompare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_localeAwareCompare02
static int tolua_luaQString_QString_localeAwareCompare02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QStringRef* s = ((const QStringRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'localeAwareCompare'", NULL);
#endif
  {
   int tolua_ret = (int)  self->localeAwareCompare(*s);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_localeAwareCompare01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: localeAwareCompare of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_localeAwareCompare03
static int tolua_luaQString_QString_localeAwareCompare03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QStringRef",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* s1 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QStringRef* s2 = ((const QStringRef*)  tolua_tousertype(tolua_S,3,0));
  {
   int tolua_ret = (int)  QString::localeAwareCompare(*s1,*s2);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_localeAwareCompare02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: toShort of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toShort00
static int tolua_luaQString_QString_toShort00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  bool ok = ((bool)  tolua_toboolean(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toShort'", NULL);
#endif
  {
   short tolua_ret = (short)  self->toShort(&ok,base);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   tolua_pushboolean(tolua_S,(bool)ok);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toShort'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toUShort of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toUShort00
static int tolua_luaQString_QString_toUShort00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  bool ok = ((bool)  tolua_toboolean(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toUShort'", NULL);
#endif
  {
   ushort tolua_ret = (ushort)  self->toUShort(&ok,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((ushort)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"ushort");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(ushort));
     tolua_pushusertype(tolua_S,tolua_obj,"ushort");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushboolean(tolua_S,(bool)ok);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toUShort'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toInt of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toInt00
static int tolua_luaQString_QString_toInt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  bool ok = ((bool)  tolua_toboolean(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toInt'", NULL);
#endif
  {
   int tolua_ret = (int)  self->toInt(&ok,base);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   tolua_pushboolean(tolua_S,(bool)ok);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toInt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toUInt of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toUInt00
static int tolua_luaQString_QString_toUInt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  bool ok = ((bool)  tolua_toboolean(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toUInt'", NULL);
#endif
  {
   uint tolua_ret = (uint)  self->toUInt(&ok,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((uint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"uint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(uint));
     tolua_pushusertype(tolua_S,tolua_obj,"uint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushboolean(tolua_S,(bool)ok);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toUInt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toLong of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toLong00
static int tolua_luaQString_QString_toLong00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  bool ok = ((bool)  tolua_toboolean(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toLong'", NULL);
#endif
  {
   long tolua_ret = (long)  self->toLong(&ok,base);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   tolua_pushboolean(tolua_S,(bool)ok);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toLong'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toULong of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toULong00
static int tolua_luaQString_QString_toULong00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  bool ok = ((bool)  tolua_toboolean(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toULong'", NULL);
#endif
  {
   ulong tolua_ret = (ulong)  self->toULong(&ok,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((ulong)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"ulong");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(ulong));
     tolua_pushusertype(tolua_S,tolua_obj,"ulong");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushboolean(tolua_S,(bool)ok);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toULong'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toLongLong of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toLongLong00
static int tolua_luaQString_QString_toLongLong00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  bool ok = ((bool)  tolua_toboolean(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toLongLong'", NULL);
#endif
  {
   qlonglong tolua_ret = (qlonglong)  self->toLongLong(&ok,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((qlonglong)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"qlonglong");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(qlonglong));
     tolua_pushusertype(tolua_S,tolua_obj,"qlonglong");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushboolean(tolua_S,(bool)ok);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toLongLong'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toULongLong of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toULongLong00
static int tolua_luaQString_QString_toULongLong00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  bool ok = ((bool)  tolua_toboolean(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toULongLong'", NULL);
#endif
  {
   qulonglong tolua_ret = (qulonglong)  self->toULongLong(&ok,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((qulonglong)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"qulonglong");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(qulonglong));
     tolua_pushusertype(tolua_S,tolua_obj,"qulonglong");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushboolean(tolua_S,(bool)ok);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toULongLong'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toFloat of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toFloat00
static int tolua_luaQString_QString_toFloat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  bool ok = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toFloat'", NULL);
#endif
  {
   float tolua_ret = (float)  self->toFloat(&ok);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   tolua_pushboolean(tolua_S,(bool)ok);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toFloat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toDouble of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toDouble00
static int tolua_luaQString_QString_toDouble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  bool ok = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toDouble'", NULL);
#endif
  {
   double tolua_ret = (double)  self->toDouble(&ok);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   tolua_pushboolean(tolua_S,(bool)ok);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toDouble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNum of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setNum00
static int tolua_luaQString_QString_setNum00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  short tolua_var_12 = ((short)  tolua_tonumber(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNum'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setNum(tolua_var_12,base);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNum'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNum of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setNum01
static int tolua_luaQString_QString_setNum01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"ushort",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  ushort tolua_var_13 = *((ushort*)  tolua_tousertype(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNum'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setNum(tolua_var_13,base);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_setNum00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNum of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setNum02
static int tolua_luaQString_QString_setNum02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int tolua_var_14 = ((int)  tolua_tonumber(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNum'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setNum(tolua_var_14,base);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_setNum01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNum of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setNum03
static int tolua_luaQString_QString_setNum03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"uint",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  uint tolua_var_15 = *((uint*)  tolua_tousertype(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNum'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setNum(tolua_var_15,base);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_setNum02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNum of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setNum04
static int tolua_luaQString_QString_setNum04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  long tolua_var_16 = ((long)  tolua_tonumber(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNum'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setNum(tolua_var_16,base);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_setNum03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNum of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setNum05
static int tolua_luaQString_QString_setNum05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"ulong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  ulong tolua_var_17 = *((ulong*)  tolua_tousertype(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNum'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setNum(tolua_var_17,base);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_setNum04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNum of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setNum06
static int tolua_luaQString_QString_setNum06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"qlonglong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  qlonglong tolua_var_18 = *((qlonglong*)  tolua_tousertype(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNum'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setNum(tolua_var_18,base);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_setNum05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNum of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setNum07
static int tolua_luaQString_QString_setNum07(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"qulonglong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  qulonglong tolua_var_19 = *((qulonglong*)  tolua_tousertype(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNum'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setNum(tolua_var_19,base);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_setNum06(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNum of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setNum08
static int tolua_luaQString_QString_setNum08(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  float tolua_var_20 = ((float)  tolua_tonumber(tolua_S,2,0));
  char f = ((char)  tolua_tonumber(tolua_S,3,'g'));
  int prec = ((int)  tolua_tonumber(tolua_S,4,6));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNum'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setNum(tolua_var_20,f,prec);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_setNum07(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNum of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_setNum09
static int tolua_luaQString_QString_setNum09(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  double tolua_var_21 = ((double)  tolua_tonumber(tolua_S,2,0));
  char f = ((char)  tolua_tonumber(tolua_S,3,'g'));
  int prec = ((int)  tolua_tonumber(tolua_S,4,6));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNum'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->setNum(tolua_var_21,f,prec);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_setNum08(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: number of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_number00
static int tolua_luaQString_QString_number00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int tolua_var_22 = ((int)  tolua_tonumber(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
  {
   QString tolua_ret = (QString)  QString::number(tolua_var_22,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'number'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: number of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_number01
static int tolua_luaQString_QString_number01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"uint",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  uint tolua_var_23 = *((uint*)  tolua_tousertype(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
  {
   QString tolua_ret = (QString)  QString::number(tolua_var_23,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_number00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: number of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_number02
static int tolua_luaQString_QString_number02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  long tolua_var_24 = ((long)  tolua_tonumber(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
  {
   QString tolua_ret = (QString)  QString::number(tolua_var_24,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_number01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: number of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_number03
static int tolua_luaQString_QString_number03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"ulong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  ulong tolua_var_25 = *((ulong*)  tolua_tousertype(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
  {
   QString tolua_ret = (QString)  QString::number(tolua_var_25,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_number02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: number of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_number04
static int tolua_luaQString_QString_number04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"qlonglong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  qlonglong tolua_var_26 = *((qlonglong*)  tolua_tousertype(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
  {
   QString tolua_ret = (QString)  QString::number(tolua_var_26,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_number03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: number of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_number05
static int tolua_luaQString_QString_number05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"qulonglong",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  qulonglong tolua_var_27 = *((qulonglong*)  tolua_tousertype(tolua_S,2,0));
  int base = ((int)  tolua_tonumber(tolua_S,3,10));
  {
   QString tolua_ret = (QString)  QString::number(tolua_var_27,base);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_number04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: number of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_number06
static int tolua_luaQString_QString_number06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  double tolua_var_28 = ((double)  tolua_tonumber(tolua_S,2,0));
  char f = ((char)  tolua_tonumber(tolua_S,3,'g'));
  int prec = ((int)  tolua_tonumber(tolua_S,4,6));
  {
   QString tolua_ret = (QString)  QString::number(tolua_var_28,f,prec);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_number05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__eq00
static int tolua_luaQString_QString__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator==(s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator< of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__lt00
static int tolua_luaQString_QString__lt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator<'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator<(s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.lt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator<= of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__le00
static int tolua_luaQString_QString__le00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QLatin1String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  QLatin1String s = *((QLatin1String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator<='", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator<=(s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.le'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: prepend of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_prepend05
static int tolua_luaQString_QString_prepend05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const char* s = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'prepend'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->prepend(s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_prepend04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: prepend of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_prepend06
static int tolua_luaQString_QString_prepend06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QByteArray* s = ((const QByteArray*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'prepend'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->prepend(*s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_prepend05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: append of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_append05
static int tolua_luaQString_QString_append05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const char* s = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'append'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->append(s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_append04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: append of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_append06
static int tolua_luaQString_QString_append06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QByteArray* s = ((const QByteArray*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'append'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->append(*s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_append05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: insert of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_insert05
static int tolua_luaQString_QString_insert05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  const char* s = ((const char*)  tolua_tostring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->insert(i,s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_insert04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: insert of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_insert06
static int tolua_luaQString_QString_insert06(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  int i = ((int)  tolua_tonumber(tolua_S,2,0));
  const QByteArray* s = ((const QByteArray*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert'", NULL);
#endif
  {
   QString& tolua_ret = (QString&)  self->insert(i,*s);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"QString");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString_insert05(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__eq01
static int tolua_luaQString_QString__eq01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const char* s = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator==(s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString__eq00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator< of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__lt01
static int tolua_luaQString_QString__lt01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const char* s = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator<'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator<(s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString__lt00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator<= of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__le01
static int tolua_luaQString_QString__le01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const char* s = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator<='", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator<=(s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString__le00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__eq02
static int tolua_luaQString_QString__eq02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QByteArray* s = ((const QByteArray*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator==(*s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString__eq01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator< of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__lt02
static int tolua_luaQString_QString__lt02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QByteArray* s = ((const QByteArray*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator<'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator<(*s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString__lt01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator<= of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString__le02
static int tolua_luaQString_QString__le02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QByteArray",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
  const QByteArray* s = ((const QByteArray*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator<='", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator<=(*s);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQString_QString__le01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_push_back00
static int tolua_luaQString_QString_push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(c);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_push_back01
static int tolua_luaQString_QString_push_back01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(*s);
  }
 }
 return 0;
tolua_lerror:
 return tolua_luaQString_QString_push_back00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_front of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_push_front00
static int tolua_luaQString_QString_push_front00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"QChar",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  QChar c = *((QChar*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_front'", NULL);
#endif
  {
   self->push_front(c);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_front'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_front of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_push_front01
static int tolua_luaQString_QString_push_front01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QString* self = (QString*)  tolua_tousertype(tolua_S,1,0);
  const QString* s = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_front'", NULL);
#endif
  {
   self->push_front(*s);
  }
 }
 return 0;
tolua_lerror:
 return tolua_luaQString_QString_push_front00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromStdString of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromStdString00
static int tolua_luaQString_QString_fromStdString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string s = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   QString tolua_ret = (QString)  QString::fromStdString(s);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushcppstring(tolua_S,(const char*)s);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromStdString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStdString of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toStdString00
static int tolua_luaQString_QString_toStdString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStdString'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->toStdString();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStdString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromStdWString of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_fromStdWString00
static int tolua_luaQString_QString_fromStdWString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QString",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const std::wstring",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::wstring* s = ((const std::wstring*)  tolua_tousertype(tolua_S,2,0));
  {
   QString tolua_ret = (QString)  QString::fromStdWString(*s);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromStdWString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStdWString of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_toStdWString00
static int tolua_luaQString_QString_toStdWString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStdWString'", NULL);
#endif
  {
   std::wstring tolua_ret = (std::wstring)  self->toStdWString();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::wstring)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::wstring");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::wstring));
     tolua_pushusertype(tolua_S,tolua_obj,"std::wstring");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStdWString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isNull of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_isNull00
static int tolua_luaQString_QString_isNull00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isNull'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isNull();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isNull'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isSimpleText of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_isSimpleText00
static int tolua_luaQString_QString_isSimpleText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isSimpleText'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isSimpleText();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isSimpleText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isRightToLeft of class  QString */
#ifndef TOLUA_DISABLE_tolua_luaQString_QString_isRightToLeft00
static int tolua_luaQString_QString_isRightToLeft00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QString",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* self = (const QString*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isRightToLeft'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isRightToLeft();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isRightToLeft'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_luaQString_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"QLatin1String","QLatin1String","",tolua_collect_QLatin1String);
  #else
  tolua_cclass(tolua_S,"QLatin1String","QLatin1String","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"QLatin1String");
   tolua_function(tolua_S,"new",tolua_luaQString_QLatin1String_new00);
   tolua_function(tolua_S,"new_local",tolua_luaQString_QLatin1String_new00_local);
   tolua_function(tolua_S,".call",tolua_luaQString_QLatin1String_new00_local);
   tolua_function(tolua_S,"new",tolua_luaQString_QLatin1String_new01);
   tolua_function(tolua_S,"new_local",tolua_luaQString_QLatin1String_new01_local);
   tolua_function(tolua_S,".call",tolua_luaQString_QLatin1String_new01_local);
   tolua_function(tolua_S,"new",tolua_luaQString_QLatin1String_new02);
   tolua_function(tolua_S,"new_local",tolua_luaQString_QLatin1String_new02_local);
   tolua_function(tolua_S,".call",tolua_luaQString_QLatin1String_new02_local);
   tolua_function(tolua_S,"new",tolua_luaQString_QLatin1String_new03);
   tolua_function(tolua_S,"new_local",tolua_luaQString_QLatin1String_new03_local);
   tolua_function(tolua_S,".call",tolua_luaQString_QLatin1String_new03_local);
   tolua_function(tolua_S,"latin1",tolua_luaQString_QLatin1String_latin100);
   tolua_function(tolua_S,"size",tolua_luaQString_QLatin1String_size00);
   tolua_function(tolua_S,"data",tolua_luaQString_QLatin1String_data00);
   tolua_function(tolua_S,"at",tolua_luaQString_QLatin1String_at00);
   tolua_function(tolua_S,".geti",tolua_luaQString_QLatin1String__geti00);
   tolua_function(tolua_S,"mid",tolua_luaQString_QLatin1String_mid00);
   tolua_function(tolua_S,"mid",tolua_luaQString_QLatin1String_mid01);
   tolua_function(tolua_S,"left",tolua_luaQString_QLatin1String_left00);
   tolua_function(tolua_S,"right",tolua_luaQString_QLatin1String_right00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"QString","QString","",tolua_collect_QString);
  #else
  tolua_cclass(tolua_S,"QString","QString","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"QString");
   tolua_function(tolua_S,"new",tolua_luaQString_QString_new00);
   tolua_function(tolua_S,"new_local",tolua_luaQString_QString_new00_local);
   tolua_function(tolua_S,".call",tolua_luaQString_QString_new00_local);
   tolua_function(tolua_S,"new",tolua_luaQString_QString_new01);
   tolua_function(tolua_S,"new_local",tolua_luaQString_QString_new01_local);
   tolua_function(tolua_S,".call",tolua_luaQString_QString_new01_local);
   tolua_function(tolua_S,"new",tolua_luaQString_QString_new02);
   tolua_function(tolua_S,"new_local",tolua_luaQString_QString_new02_local);
   tolua_function(tolua_S,".call",tolua_luaQString_QString_new02_local);
   tolua_function(tolua_S,"new",tolua_luaQString_QString_new03);
   tolua_function(tolua_S,"new_local",tolua_luaQString_QString_new03_local);
   tolua_function(tolua_S,".call",tolua_luaQString_QString_new03_local);
   tolua_function(tolua_S,"new",tolua_luaQString_QString_new04);
   tolua_function(tolua_S,"new_local",tolua_luaQString_QString_new04_local);
   tolua_function(tolua_S,".call",tolua_luaQString_QString_new04_local);
   tolua_function(tolua_S,"new",tolua_luaQString_QString_new05);
   tolua_function(tolua_S,"new_local",tolua_luaQString_QString_new05_local);
   tolua_function(tolua_S,".call",tolua_luaQString_QString_new05_local);
   tolua_function(tolua_S,"delete",tolua_luaQString_QString_delete00);
   tolua_function(tolua_S,"size",tolua_luaQString_QString_size00);
   tolua_function(tolua_S,"count",tolua_luaQString_QString_count00);
   tolua_function(tolua_S,"length",tolua_luaQString_QString_length00);
   tolua_function(tolua_S,"isEmpty",tolua_luaQString_QString_isEmpty00);
   tolua_function(tolua_S,"resize",tolua_luaQString_QString_resize00);
   tolua_function(tolua_S,"resize",tolua_luaQString_QString_resize01);
   tolua_function(tolua_S,"fill",tolua_luaQString_QString_fill00);
   tolua_function(tolua_S,"truncate",tolua_luaQString_QString_truncate00);
   tolua_function(tolua_S,"chop",tolua_luaQString_QString_chop00);
   tolua_function(tolua_S,"capacity",tolua_luaQString_QString_capacity00);
   tolua_function(tolua_S,"reserve",tolua_luaQString_QString_reserve00);
   tolua_function(tolua_S,"squeeze",tolua_luaQString_QString_squeeze00);
   tolua_function(tolua_S,"unicode",tolua_luaQString_QString_unicode00);
   tolua_function(tolua_S,"data",tolua_luaQString_QString_data00);
   tolua_function(tolua_S,"data",tolua_luaQString_QString_data01);
   tolua_function(tolua_S,"constData",tolua_luaQString_QString_constData00);
   tolua_function(tolua_S,"detach",tolua_luaQString_QString_detach00);
   tolua_function(tolua_S,"isDetached",tolua_luaQString_QString_isDetached00);
   tolua_function(tolua_S,"isSharedWith",tolua_luaQString_QString_isSharedWith00);
   tolua_function(tolua_S,"clear",tolua_luaQString_QString_clear00);
   tolua_function(tolua_S,"at",tolua_luaQString_QString_at00);
   tolua_function(tolua_S,".geti",tolua_luaQString_QString__geti00);
   tolua_function(tolua_S,".geti",tolua_luaQString_QString__geti01);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg00);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg01);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg02);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg03);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg04);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg05);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg06);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg07);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg08);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg09);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg10);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg11);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg12);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg13);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg14);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg15);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg16);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg17);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg18);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg19);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg20);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg21);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg22);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg23);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg24);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg25);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg26);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg27);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg28);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg29);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg30);
   tolua_function(tolua_S,"arg",tolua_luaQString_QString_arg31);
   tolua_function(tolua_S,"indexOf",tolua_luaQString_QString_indexOf00);
   tolua_function(tolua_S,"indexOf",tolua_luaQString_QString_indexOf01);
   tolua_function(tolua_S,"indexOf",tolua_luaQString_QString_indexOf02);
   tolua_function(tolua_S,"indexOf",tolua_luaQString_QString_indexOf03);
   tolua_function(tolua_S,"lastIndexOf",tolua_luaQString_QString_lastIndexOf00);
   tolua_function(tolua_S,"lastIndexOf",tolua_luaQString_QString_lastIndexOf01);
   tolua_function(tolua_S,"lastIndexOf",tolua_luaQString_QString_lastIndexOf02);
   tolua_function(tolua_S,"lastIndexOf",tolua_luaQString_QString_lastIndexOf03);
   tolua_function(tolua_S,"contains",tolua_luaQString_QString_contains00);
   tolua_function(tolua_S,"contains",tolua_luaQString_QString_contains01);
   tolua_function(tolua_S,"contains",tolua_luaQString_QString_contains02);
   tolua_function(tolua_S,"contains",tolua_luaQString_QString_contains03);
   tolua_function(tolua_S,"count",tolua_luaQString_QString_count01);
   tolua_function(tolua_S,"count",tolua_luaQString_QString_count02);
   tolua_function(tolua_S,"count",tolua_luaQString_QString_count03);
   tolua_function(tolua_S,"indexOf",tolua_luaQString_QString_indexOf04);
   tolua_function(tolua_S,"lastIndexOf",tolua_luaQString_QString_lastIndexOf04);
   tolua_function(tolua_S,"contains",tolua_luaQString_QString_contains04);
   tolua_function(tolua_S,"count",tolua_luaQString_QString_count04);
   tolua_function(tolua_S,"indexOf",tolua_luaQString_QString_indexOf05);
   tolua_function(tolua_S,"lastIndexOf",tolua_luaQString_QString_lastIndexOf05);
   tolua_function(tolua_S,"contains",tolua_luaQString_QString_contains05);
   tolua_function(tolua_S,"indexOf",tolua_luaQString_QString_indexOf06);
   tolua_function(tolua_S,"indexOf",tolua_luaQString_QString_indexOf07);
   tolua_function(tolua_S,"lastIndexOf",tolua_luaQString_QString_lastIndexOf06);
   tolua_function(tolua_S,"lastIndexOf",tolua_luaQString_QString_lastIndexOf07);
   tolua_function(tolua_S,"contains",tolua_luaQString_QString_contains06);
   tolua_function(tolua_S,"contains",tolua_luaQString_QString_contains07);
   tolua_function(tolua_S,"count",tolua_luaQString_QString_count05);
   tolua_constant(tolua_S,"SectionDefault",QString::SectionDefault);
   tolua_constant(tolua_S,"SectionSkipEmpty",QString::SectionSkipEmpty);
   tolua_constant(tolua_S,"SectionIncludeLeadingSep",QString::SectionIncludeLeadingSep);
   tolua_constant(tolua_S,"SectionIncludeTrailingSep",QString::SectionIncludeTrailingSep);
   tolua_constant(tolua_S,"SectionCaseInsensitiveSeps",QString::SectionCaseInsensitiveSeps);
   tolua_function(tolua_S,"section",tolua_luaQString_QString_section00);
   tolua_function(tolua_S,"section",tolua_luaQString_QString_section01);
   tolua_function(tolua_S,"section",tolua_luaQString_QString_section02);
   tolua_function(tolua_S,"section",tolua_luaQString_QString_section03);
   tolua_function(tolua_S,"left",tolua_luaQString_QString_left00);
   tolua_function(tolua_S,"right",tolua_luaQString_QString_right00);
   tolua_function(tolua_S,"mid",tolua_luaQString_QString_mid00);
   tolua_function(tolua_S,"leftRef",tolua_luaQString_QString_leftRef00);
   tolua_function(tolua_S,"rightRef",tolua_luaQString_QString_rightRef00);
   tolua_function(tolua_S,"midRef",tolua_luaQString_QString_midRef00);
   tolua_function(tolua_S,"startsWith",tolua_luaQString_QString_startsWith00);
   tolua_function(tolua_S,"startsWith",tolua_luaQString_QString_startsWith01);
   tolua_function(tolua_S,"startsWith",tolua_luaQString_QString_startsWith02);
   tolua_function(tolua_S,"startsWith",tolua_luaQString_QString_startsWith03);
   tolua_function(tolua_S,"endsWith",tolua_luaQString_QString_endsWith00);
   tolua_function(tolua_S,"endsWith",tolua_luaQString_QString_endsWith01);
   tolua_function(tolua_S,"endsWith",tolua_luaQString_QString_endsWith02);
   tolua_function(tolua_S,"endsWith",tolua_luaQString_QString_endsWith03);
   tolua_function(tolua_S,"leftJustified",tolua_luaQString_QString_leftJustified00);
   tolua_function(tolua_S,"leftJustified",tolua_luaQString_QString_leftJustified01);
   tolua_function(tolua_S,"rightJustified",tolua_luaQString_QString_rightJustified00);
   tolua_function(tolua_S,"rightJustified",tolua_luaQString_QString_rightJustified01);
   tolua_function(tolua_S,"toLower",tolua_luaQString_QString_toLower00);
   tolua_function(tolua_S,"toUpper",tolua_luaQString_QString_toUpper00);
   tolua_function(tolua_S,"toCaseFolded",tolua_luaQString_QString_toCaseFolded00);
   tolua_function(tolua_S,"trimmed",tolua_luaQString_QString_trimmed00);
   tolua_function(tolua_S,"simplified",tolua_luaQString_QString_simplified00);
   tolua_function(tolua_S,"toHtmlEscaped",tolua_luaQString_QString_toHtmlEscaped00);
   tolua_function(tolua_S,"insert",tolua_luaQString_QString_insert00);
   tolua_function(tolua_S,"insert",tolua_luaQString_QString_insert01);
   tolua_function(tolua_S,"insert",tolua_luaQString_QString_insert02);
   tolua_function(tolua_S,"insert",tolua_luaQString_QString_insert03);
   tolua_function(tolua_S,"insert",tolua_luaQString_QString_insert04);
   tolua_function(tolua_S,"append",tolua_luaQString_QString_append00);
   tolua_function(tolua_S,"append",tolua_luaQString_QString_append01);
   tolua_function(tolua_S,"append",tolua_luaQString_QString_append02);
   tolua_function(tolua_S,"append",tolua_luaQString_QString_append03);
   tolua_function(tolua_S,"append",tolua_luaQString_QString_append04);
   tolua_function(tolua_S,"prepend",tolua_luaQString_QString_prepend00);
   tolua_function(tolua_S,"prepend",tolua_luaQString_QString_prepend01);
   tolua_function(tolua_S,"prepend",tolua_luaQString_QString_prepend02);
   tolua_function(tolua_S,"prepend",tolua_luaQString_QString_prepend03);
   tolua_function(tolua_S,"prepend",tolua_luaQString_QString_prepend04);
   tolua_function(tolua_S,"remove",tolua_luaQString_QString_remove00);
   tolua_function(tolua_S,"remove",tolua_luaQString_QString_remove01);
   tolua_function(tolua_S,"remove",tolua_luaQString_QString_remove02);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace00);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace01);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace02);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace03);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace04);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace05);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace06);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace07);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace08);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace09);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace10);
   tolua_function(tolua_S,"replace",tolua_luaQString_QString_replace11);
   tolua_function(tolua_S,"remove",tolua_luaQString_QString_remove03);
   tolua_constant(tolua_S,"KeepEmptyParts",QString::KeepEmptyParts);
   tolua_constant(tolua_S,"SkipEmptyParts",QString::SkipEmptyParts);
   tolua_function(tolua_S,"split",tolua_luaQString_QString_split00);
   tolua_function(tolua_S,"splitRef",tolua_luaQString_QString_splitRef00);
   tolua_function(tolua_S,"split",tolua_luaQString_QString_split01);
   tolua_function(tolua_S,"splitRef",tolua_luaQString_QString_splitRef01);
   tolua_function(tolua_S,"split",tolua_luaQString_QString_split02);
   tolua_function(tolua_S,"splitRef",tolua_luaQString_QString_splitRef02);
   tolua_function(tolua_S,"split",tolua_luaQString_QString_split03);
   tolua_function(tolua_S,"splitRef",tolua_luaQString_QString_splitRef03);
   tolua_constant(tolua_S,"NormalizationForm_D",QString::NormalizationForm_D);
   tolua_constant(tolua_S,"NormalizationForm_C",QString::NormalizationForm_C);
   tolua_constant(tolua_S,"NormalizationForm_KD",QString::NormalizationForm_KD);
   tolua_constant(tolua_S,"NormalizationForm_KC",QString::NormalizationForm_KC);
   tolua_function(tolua_S,"normalized",tolua_luaQString_QString_normalized00);
   tolua_function(tolua_S,"repeated",tolua_luaQString_QString_repeated00);
   tolua_function(tolua_S,"utf16",tolua_luaQString_QString_utf1600);
   tolua_function(tolua_S,"toLatin1",tolua_luaQString_QString_toLatin100);
   tolua_function(tolua_S,"toUtf8",tolua_luaQString_QString_toUtf800);
   tolua_function(tolua_S,"toLocal8Bit",tolua_luaQString_QString_toLocal8Bit00);
   tolua_function(tolua_S,"toUcs4",tolua_luaQString_QString_toUcs400);
   tolua_function(tolua_S,"fromLatin1",tolua_luaQString_QString_fromLatin100);
   tolua_function(tolua_S,"fromUtf8",tolua_luaQString_QString_fromUtf800);
   tolua_function(tolua_S,"fromLocal8Bit",tolua_luaQString_QString_fromLocal8Bit00);
   tolua_function(tolua_S,"fromLatin1",tolua_luaQString_QString_fromLatin101);
   tolua_function(tolua_S,"fromUtf8",tolua_luaQString_QString_fromUtf801);
   tolua_function(tolua_S,"fromLocal8Bit",tolua_luaQString_QString_fromLocal8Bit01);
   tolua_function(tolua_S,"fromUtf16",tolua_luaQString_QString_fromUtf1600);
   tolua_function(tolua_S,"fromUcs4",tolua_luaQString_QString_fromUcs400);
   tolua_function(tolua_S,"fromRawData",tolua_luaQString_QString_fromRawData00);
   tolua_function(tolua_S,"fromUtf16",tolua_luaQString_QString_fromUtf1601);
   tolua_function(tolua_S,"fromUcs4",tolua_luaQString_QString_fromUcs401);
   tolua_function(tolua_S,"toWCharArray",tolua_luaQString_QString_toWCharArray00);
   tolua_function(tolua_S,"fromWCharArray",tolua_luaQString_QString_fromWCharArray00);
   tolua_function(tolua_S,"setRawData",tolua_luaQString_QString_setRawData00);
   tolua_function(tolua_S,"setUnicode",tolua_luaQString_QString_setUnicode00);
   tolua_function(tolua_S,"setUtf16",tolua_luaQString_QString_setUtf1600);
   tolua_function(tolua_S,"compare",tolua_luaQString_QString_compare00);
   tolua_function(tolua_S,"compare",tolua_luaQString_QString_compare01);
   tolua_function(tolua_S,"compare",tolua_luaQString_QString_compare02);
   tolua_function(tolua_S,"compare",tolua_luaQString_QString_compare03);
   tolua_function(tolua_S,"compare",tolua_luaQString_QString_compare04);
   tolua_function(tolua_S,"compare",tolua_luaQString_QString_compare05);
   tolua_function(tolua_S,"compare",tolua_luaQString_QString_compare06);
   tolua_function(tolua_S,"localeAwareCompare",tolua_luaQString_QString_localeAwareCompare00);
   tolua_function(tolua_S,"localeAwareCompare",tolua_luaQString_QString_localeAwareCompare01);
   tolua_function(tolua_S,"localeAwareCompare",tolua_luaQString_QString_localeAwareCompare02);
   tolua_function(tolua_S,"localeAwareCompare",tolua_luaQString_QString_localeAwareCompare03);
   tolua_function(tolua_S,"toShort",tolua_luaQString_QString_toShort00);
   tolua_function(tolua_S,"toUShort",tolua_luaQString_QString_toUShort00);
   tolua_function(tolua_S,"toInt",tolua_luaQString_QString_toInt00);
   tolua_function(tolua_S,"toUInt",tolua_luaQString_QString_toUInt00);
   tolua_function(tolua_S,"toLong",tolua_luaQString_QString_toLong00);
   tolua_function(tolua_S,"toULong",tolua_luaQString_QString_toULong00);
   tolua_function(tolua_S,"toLongLong",tolua_luaQString_QString_toLongLong00);
   tolua_function(tolua_S,"toULongLong",tolua_luaQString_QString_toULongLong00);
   tolua_function(tolua_S,"toFloat",tolua_luaQString_QString_toFloat00);
   tolua_function(tolua_S,"toDouble",tolua_luaQString_QString_toDouble00);
   tolua_function(tolua_S,"setNum",tolua_luaQString_QString_setNum00);
   tolua_function(tolua_S,"setNum",tolua_luaQString_QString_setNum01);
   tolua_function(tolua_S,"setNum",tolua_luaQString_QString_setNum02);
   tolua_function(tolua_S,"setNum",tolua_luaQString_QString_setNum03);
   tolua_function(tolua_S,"setNum",tolua_luaQString_QString_setNum04);
   tolua_function(tolua_S,"setNum",tolua_luaQString_QString_setNum05);
   tolua_function(tolua_S,"setNum",tolua_luaQString_QString_setNum06);
   tolua_function(tolua_S,"setNum",tolua_luaQString_QString_setNum07);
   tolua_function(tolua_S,"setNum",tolua_luaQString_QString_setNum08);
   tolua_function(tolua_S,"setNum",tolua_luaQString_QString_setNum09);
   tolua_function(tolua_S,"number",tolua_luaQString_QString_number00);
   tolua_function(tolua_S,"number",tolua_luaQString_QString_number01);
   tolua_function(tolua_S,"number",tolua_luaQString_QString_number02);
   tolua_function(tolua_S,"number",tolua_luaQString_QString_number03);
   tolua_function(tolua_S,"number",tolua_luaQString_QString_number04);
   tolua_function(tolua_S,"number",tolua_luaQString_QString_number05);
   tolua_function(tolua_S,"number",tolua_luaQString_QString_number06);
   tolua_function(tolua_S,".eq",tolua_luaQString_QString__eq00);
   tolua_function(tolua_S,".lt",tolua_luaQString_QString__lt00);
   tolua_function(tolua_S,".le",tolua_luaQString_QString__le00);
   tolua_function(tolua_S,"prepend",tolua_luaQString_QString_prepend05);
   tolua_function(tolua_S,"prepend",tolua_luaQString_QString_prepend06);
   tolua_function(tolua_S,"append",tolua_luaQString_QString_append05);
   tolua_function(tolua_S,"append",tolua_luaQString_QString_append06);
   tolua_function(tolua_S,"insert",tolua_luaQString_QString_insert05);
   tolua_function(tolua_S,"insert",tolua_luaQString_QString_insert06);
   tolua_function(tolua_S,".eq",tolua_luaQString_QString__eq01);
   tolua_function(tolua_S,".lt",tolua_luaQString_QString__lt01);
   tolua_function(tolua_S,".le",tolua_luaQString_QString__le01);
   tolua_function(tolua_S,".eq",tolua_luaQString_QString__eq02);
   tolua_function(tolua_S,".lt",tolua_luaQString_QString__lt02);
   tolua_function(tolua_S,".le",tolua_luaQString_QString__le02);
   tolua_function(tolua_S,"push_back",tolua_luaQString_QString_push_back00);
   tolua_function(tolua_S,"push_back",tolua_luaQString_QString_push_back01);
   tolua_function(tolua_S,"push_front",tolua_luaQString_QString_push_front00);
   tolua_function(tolua_S,"push_front",tolua_luaQString_QString_push_front01);
   tolua_function(tolua_S,"fromStdString",tolua_luaQString_QString_fromStdString00);
   tolua_function(tolua_S,"toStdString",tolua_luaQString_QString_toStdString00);
   tolua_function(tolua_S,"fromStdWString",tolua_luaQString_QString_fromStdWString00);
   tolua_function(tolua_S,"toStdWString",tolua_luaQString_QString_toStdWString00);
   tolua_function(tolua_S,"isNull",tolua_luaQString_QString_isNull00);
   tolua_function(tolua_S,"isSimpleText",tolua_luaQString_QString_isSimpleText00);
   tolua_function(tolua_S,"isRightToLeft",tolua_luaQString_QString_isRightToLeft00);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_luaQString (lua_State* tolua_S) {
 return tolua_luaQString_open(tolua_S);
};
#endif

